Integrating Maps and Location-Based Features in Android

Course: Android App Development

Topic: Integrating Maps and Location-Based Features

Course Link: Android App Development Course

Demo Link: Register for a Course Demo

Website: JustAcademy

1. Introduction

Maps and location-based features are important parts of modern Android applications. They allow applications to display geographical locations, identify a user's approximate or precise position, show nearby places, calculate routes, and provide services based on geographical coordinates.

For example, a food delivery application can display a restaurant and delivery address on a map. A travel application can show attractions near the user. A task management application can associate tasks with a job site, while a fitness application can record a route during an activity.

Android developers can integrate Google Maps using the Maps SDK for Android and obtain device location using the Google Play services Location API. These technologies serve different purposes: Maps SDK displays and manages the map interface, while the location API obtains location information from available device providers.

Learning Objectives

• Understand maps and location-based services in Android.
• Configure Google Maps Platform for an Android application.
• Display an interactive Google Map inside an application.
• Add markers and customize map camera movement.
• Request location permissions correctly.
• Retrieve the device's current location using Fused Location Provider.
• Display the user's position on a map.
• Understand latitude, longitude, geocoding, and reverse geocoding.
• Explore nearby places, directions, and geofencing.
• Apply privacy, performance, and security best practices.

2. Understanding Location-Based Services

A location-based service uses geographical information to provide relevant functionality. The location may come from GPS, Wi-Fi, cellular networks, device sensors, a manually selected map point, or a saved address converted into coordinates.

Common Applications

• Navigation and route planning.
• Ride-booking and delivery tracking.
• Finding nearby restaurants, hospitals, shops, or ATMs.
• Displaying a user's current location.
• Location sharing between authorized users.
• Geofencing for entry and exit notifications.
• Showing service centers or business branches on a map.
• Recording routes for fitness or travel applications.

3. Important Location Concepts

4. Google Maps SDK and Location APIs

Maps and location services are related but separate capabilities. A map can be displayed without accessing the device's location, and an application can obtain coordinates without embedding a map.

Google Maps Platform services may require billing configuration, API enablement, and suitable credentials. Check the relevant service's current pricing, usage limits, and requirements before using it in production.

5. Creating a Google Cloud Project

To display Google Maps in an Android application, configure a project through Google Cloud Console.

1. Open the Google Cloud Console.
2. Create a new project or select an existing project.
3. Configure billing if required for the selected Google Maps Platform services.
4. Enable the Maps SDK for Android.
5. Create an API key for the Android application.
6. Restrict the key to the intended Android application using its package name and signing certificate fingerprint.
7. Add the key to the Android application configuration.
8. Run the application on a compatible device or emulator and verify that the map loads.

Security note: A Maps SDK API key used in a mobile application is not a secret once included in the application package. Protect it through appropriate application restrictions, API restrictions, monitoring, and separate keys for different environments. Never place service-account credentials or other privileged server secrets inside an Android application.

Official reference: Configure the Maps SDK for Android.

6. Adding Maps SDK Dependencies

Add the Maps SDK dependency to the app module's Gradle configuration. Use the current version shown in the official setup documentation rather than relying on an outdated version number.

dependencies {
    implementation("com.google.android.gms:play-services-maps:YOUR_CURRENT_VERSION")
}

Replace YOUR_CURRENT_VERSION with a valid version from the current Maps SDK documentation.

If the application needs programmatic location data, also add the Google Play services Location dependency:

dependencies {
    implementation("com.google.android.gms:play-services-location:YOUR_CURRENT_VERSION")
}

Use compatible versions for the libraries in your project. The Maps SDK and Location API are separate dependencies, so include only those required by the implemented features.

7. Configuring the Android Manifest

The Android manifest declares application components, permissions, and configuration metadata. Internet access is generally needed to load map content.

<manifest xmlns:android="http://schemas.android.com/apk/res/android">

    <uses-permission android:name="android.permission.INTERNET" />

    <application
        android:allowBackup="true"
        android:label="Location App"
        android:theme="@style/Theme.AppCompat.Light.NoActionBar">

        <meta-data
            android:name="com.google.android.geo.API_KEY"
            android:value="${MAPS_API_KEY}" />

    </application>

</manifest>

The example uses a Gradle-provided placeholder named MAPS_API_KEY. Configure the placeholder through your local or environment-specific build configuration. Do not commit unrestricted credentials to a public source repository.

Location permissions are only required when the application needs to access device location. A map that displays fixed markers can work without requesting location permission.

8. Creating a Map Screen

Google Maps can be embedded in an Activity or Fragment. The following example uses a Fragment-based layout.

XML Layout

<?xml version="1.0" encoding="utf-8"?>
<androidx.fragment.app.FragmentContainerView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/map"
    android:name="com.google.android.gms.maps.SupportMapFragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

This layout creates a SupportMapFragment that displays the map after the SDK initializes successfully.

9. Displaying a Google Map

The Maps SDK provides the OnMapReadyCallback interface. The callback is invoked when the map is ready to be used.

Kotlin Example

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.google.android.gms.maps.GoogleMap
import com.google.android.gms.maps.OnMapReadyCallback
import com.google.android.gms.maps.SupportMapFragment

class MapsActivity : AppCompatActivity(), OnMapReadyCallback {

    private lateinit var googleMap: GoogleMap

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_maps)

        val mapFragment = supportFragmentManager
            .findFragmentById(R.id.map) as SupportMapFragment

        mapFragment.getMapAsync(this)
    }

    override fun onMapReady(map: GoogleMap) {
        googleMap = map

        googleMap.uiSettings.isZoomControlsEnabled = true
        googleMap.uiSettings.isCompassEnabled = true
    }
}

In this example, the map is initialized asynchronously. Configure markers, camera movement, and listeners after the map is ready.

10. Understanding Latitude and Longitude

Maps use geographical coordinates to identify locations. Latitude ranges from -90 to 90 degrees, while longitude ranges from -180 to 180 degrees.

For example, a location in Mumbai can be represented by a coordinate pair near latitude 19.0760 and longitude 72.8777. These coordinates are illustrative and can be used to understand how map positions work.

Creating a LatLng Object

import com.google.android.gms.maps.model.LatLng

val mumbaiLocation = LatLng(19.0760, 72.8777)

The LatLng object is used by the Maps SDK to represent a geographical position.

11. Adding Markers to the Map

A marker identifies a particular point on the map. Markers can represent a user's selected destination, a business, a meeting point, or a delivery address.

import com.google.android.gms.maps.CameraUpdateFactory
import com.google.android.gms.maps.model.LatLng
import com.google.android.gms.maps.model.MarkerOptions

override fun onMapReady(map: GoogleMap) {
    googleMap = map

    val location = LatLng(19.0760, 72.8777)

    googleMap.addMarker(
        MarkerOptions()
            .position(location)
            .title("Mumbai")
            .snippet("Example map location")
    )

    googleMap.moveCamera(
        CameraUpdateFactory.newLatLngZoom(location, 12f)
    )
}

The marker displays a title and optional snippet. The camera is moved to the selected position and zoom level.

12. Controlling the Map Camera

The map camera determines the position, zoom, tilt, and bearing of the map view. CameraUpdateFactory provides methods for changing the visible area.

Use animateCamera() for a smooth transition and moveCamera() for an immediate change. When displaying multiple markers, consider moving the camera to bounds that include all relevant locations.

13. Understanding Location Permissions

Android protects location data through runtime permissions. The application must request only the level of access needed for its feature.

On Android 12 and later, users may grant approximate location even if the app requests precise location. If precise access is genuinely necessary, request both coarse and fine permissions in the same runtime request and handle the possibility that only approximate access is granted.

Background location is subject to additional platform requirements and Google Play policy. Most map screens that use location only while visible should request foreground location instead.

Official reference: Request Location Permissions.

14. Declaring Location Permissions in the Manifest

If the application needs the user's location, declare the relevant permission in the manifest.

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

Include fine location only when precise positioning is required. If the application only displays a map with predefined markers, do not request location permission unnecessarily.

15. Requesting Location Permission at Runtime

Applications targeting modern Android versions must request dangerous permissions at runtime when required. AndroidX Activity Result APIs provide a structured way to handle permission requests.

Kotlin Example

import android.Manifest
import android.content.pm.PackageManager
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContracts
import androidx.core.content.ContextCompat

private val requestLocationPermissions =
    registerForActivityResult(
        ActivityResultContracts.RequestMultiplePermissions()
    ) { permissions ->
        val hasLocationPermission =
            permissions[Manifest.permission.ACCESS_FINE_LOCATION] == true ||
            permissions[Manifest.permission.ACCESS_COARSE_LOCATION] == true

        if (hasLocationPermission) {
            startLocationFeature()
        } else {
            Toast.makeText(
                this,
                "Location permission was not granted",
                Toast.LENGTH_SHORT
            ).show()
        }
    }

private fun checkLocationPermission() {
    val fineGranted = ContextCompat.checkSelfPermission(
        this,
        Manifest.permission.ACCESS_FINE_LOCATION
    ) == PackageManager.PERMISSION_GRANTED

    val coarseGranted = ContextCompat.checkSelfPermission(
        this,
        Manifest.permission.ACCESS_COARSE_LOCATION
    ) == PackageManager.PERMISSION_GRANTED

    if (fineGranted || coarseGranted) {
        startLocationFeature()
    } else {
        requestLocationPermissions.launch(
            arrayOf(
                Manifest.permission.ACCESS_COARSE_LOCATION,
                Manifest.permission.ACCESS_FINE_LOCATION
            )
        )
    }
}

private fun startLocationFeature() {
    // Retrieve or display the location using the appropriate API.
}

Register the launcher as part of the Activity or Fragment initialization, before the component reaches the started state. In production, check whether precise location is actually needed and provide an explanation before requesting it when appropriate.

16. Enabling the My Location Layer

The Maps SDK provides a My Location layer that displays a blue indicator for the device's location and a button that can center the map on that position.

This layer is useful for displaying the user's location, but it does not provide a location object for application logic. Use the Location API when coordinates are needed for calculations, storage, sharing, or business logic.

import android.Manifest
import android.content.pm.PackageManager
import androidx.core.content.ContextCompat

private fun enableMyLocationLayer() {
    val fineGranted = ContextCompat.checkSelfPermission(
        this,
        Manifest.permission.ACCESS_FINE_LOCATION
    ) == PackageManager.PERMISSION_GRANTED

    val coarseGranted = ContextCompat.checkSelfPermission(
        this,
        Manifest.permission.ACCESS_COARSE_LOCATION
    ) == PackageManager.PERMISSION_GRANTED

    if (fineGranted || coarseGranted) {
        googleMap.isMyLocationEnabled = true
    }
}

Call this function only after the map is ready and permission has been granted. The code omits the permission request flow, which should be implemented before invoking it. Never suppress permission checks simply to silence a compiler warning.

17. Retrieving the Current Location

The Fused Location Provider combines available location signals to provide location estimates. It can be used to retrieve a current location or request updates while the application needs them.

It is generally preferred over directly managing individual location providers for common Android location requirements.

Getting the Last Known Location

import android.annotation.SuppressLint
import android.location.Location
import com.google.android.gms.location.LocationServices

@SuppressLint("MissingPermission")
private fun getLastKnownLocation() {
    val fusedLocationClient =
        LocationServices.getFusedLocationProviderClient(this)

    fusedLocationClient.lastLocation
        .addOnSuccessListener { location: Location? ->
            if (location != null) {
                val latitude = location.latitude
                val longitude = location.longitude

                // Use the coordinates for the selected feature.
            } else {
                // No cached location is currently available.
            }
        }
        .addOnFailureListener { exception ->
            // Display or log an appropriate error.
        }
}

Only call this method after checking and obtaining an appropriate location permission. The lastLocation value may be null or stale because it is a cached result, not a guarantee of a fresh fix. If a fresh location is required, use an appropriate current-location request and handle its timeout and failure cases.

18. Displaying the Current Location on the Map

After retrieving the coordinates, the application can add a marker and move the camera to that location.

import com.google.android.gms.maps.CameraUpdateFactory
import com.google.android.gms.maps.model.LatLng
import com.google.android.gms.maps.model.MarkerOptions

private fun showLocationOnMap(
    latitude: Double,
    longitude: Double
) {
    val currentPosition = LatLng(latitude, longitude)

    googleMap.clear()

    googleMap.addMarker(
        MarkerOptions()
            .position(currentPosition)
            .title("Selected Location")
    )

    googleMap.animateCamera(
        CameraUpdateFactory.newLatLngZoom(currentPosition, 15f)
    )
}

This function displays the supplied coordinates. If the map already contains other important markers, avoid clearing them indiscriminately; update or replace only the marker that represents the current location.

19. Receiving Continuous Location Updates

Some features need more than a single location estimate. Examples include live delivery tracking, route recording, or navigation. These features can use a LocationRequest and a LocationCallback.

Before requesting updates, choose suitable accuracy and interval settings. High-frequency updates can consume additional battery and may not be necessary for many features.

Location Update Lifecycle

1. Check that the required location permission has been granted.
2. Create a LocationRequest appropriate for the feature.
3. Create a LocationCallback to receive location results.
4. Request updates while the feature needs them.
5. Process the returned coordinates.
6. Remove location updates when they are no longer needed.

For example, a delivery application may request updates during an active delivery. A profile screen that simply shows a location should generally use a one-time request instead of continuous tracking.

20. Handling Location Accuracy and Availability

Location estimates vary in accuracy. GPS signals can be weak indoors or in dense urban areas. Network-based location may provide a faster but less precise result.

• Check whether the returned location is null.
• Inspect the reported accuracy when the feature requires it.
• Consider the timestamp to identify stale results.
• Handle disabled location services gracefully.
• Explain when a feature needs precise location.
• Provide a manual location-selection alternative when possible.
• Avoid presenting an approximate coordinate as an exact address.

21. Geocoding and Reverse Geocoding

Geocoding converts an address or place description into geographical coordinates. Reverse geocoding converts coordinates into a human-readable address when a suitable result is available.

Example Use Cases

• Convert a delivery address into a map position.
• Display a readable locality for selected coordinates.
• Allow users to select a destination from a map.
• Show an address summary for a saved task location.

Android provides the Geocoder API for address lookup. Availability and results depend on the device's geocoding implementation and network conditions. For large-scale or business-critical address processing, choose a suitable supported geocoding service and review its usage policies.

Illustrative Reverse Geocoding Example

import android.location.Geocoder
import android.os.Build
import java.util.Locale

private fun getAddressFromCoordinates(
    latitude: Double,
    longitude: Double
) {
    val geocoder = Geocoder(this, Locale.getDefault())

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
        geocoder.getFromLocation(
            latitude,
            longitude,
            1
        ) { addresses ->
            val addressText = addresses.firstOrNull()
                ?.getAddressLine(0)

            runOnUiThread {
                // Display addressText if a result is available.
            }
        }
    } else {
        @Suppress("DEPRECATION")
        Thread {
            val addresses = geocoder.getFromLocation(
                latitude,
                longitude,
                1
            )

            val addressText = addresses
                ?.firstOrNull()
                ?.getAddressLine(0)

            runOnUiThread {
                // Display addressText if a result is available.
            }
        }.start()
    }
}

This example demonstrates the different Geocoder call styles. In a production application, handle exceptions, check geocoding availability where supported, avoid blocking the main thread, and show a fallback if no address is returned.

22. Showing Multiple Locations

A map can display multiple markers for places such as offices, restaurants, delivery points, or project sites.

import com.google.android.gms.maps.model.LatLng
import com.google.android.gms.maps.model.MarkerOptions

private fun addLocationMarkers() {
    val locations = listOf(
        LatLng(19.0760, 72.8777) to "Location A",
        LatLng(19.1136, 72.8697) to "Location B",
        LatLng(19.0176, 72.8562) to "Location C"
    )

    locations.forEach { (position, title) ->
        googleMap.addMarker(
            MarkerOptions()
                .position(position)
                .title(title)
        )
    }
}

The coordinates are illustrative examples for learning and should be replaced with verified coordinates for the actual places used by your application.

23. Nearby Places and Place Search

Nearby-place features help users find businesses, landmarks, and services around a selected position. Depending on the requirements, the application may use the Places API or another appropriate place-data provider.

A typical workflow includes:

1. Obtain a location or let the user choose a point on the map.
2. Determine the required place categories or search terms.
3. Query a supported place-search service.
4. Display the returned place details and locations.
5. Place markers on the map for relevant results.
6. Allow users to open place details or request directions.

Place search may involve separate APIs, billing, and data-use requirements. Review the current Google Maps Platform documentation before implementing a Places API workflow.

Official reference: Places SDK for Android Overview.

24. Displaying Routes and Directions

Route features help users navigate between an origin and a destination. A route can be displayed as a line on the map, accompanied by distance, estimated travel time, and step-by-step instructions when supported by the chosen service.

A typical route workflow includes:

1. Choose an origin, such as the user's location or a selected map point.
2. Choose a destination.
3. Request route information through an appropriate directions or routes service.
4. Process the returned route geometry and instructions.
5. Draw a polyline on the map.
6. Adjust the camera to show the route.
7. Handle unavailable routes, traffic conditions, and network failures.

The Maps SDK for Android displays map content and overlays; it does not automatically calculate every type of route merely because a map is present. Route computation generally requires a separate service or a suitable navigation solution.

25. Understanding Geofencing

Geofencing allows an application to respond when a device enters or exits a defined geographical region. A geofence is usually defined by a center coordinate and a radius.

Potential use cases include:

• Sending a reminder when a user reaches a selected location.
• Notifying a team member when they arrive at a work site.
• Supporting location-aware check-in workflows.
• Triggering a location-related task when entering an approved area.

Geofencing requires careful permission, battery, lifecycle, and background-execution design. It should not be treated as a guaranteed instant trigger, because operating-system scheduling and location conditions can affect delivery timing.

Official reference: Create and Monitor Geofences.

26. Saving Location Data to Firebase

An application may save a selected or captured location in Cloud Firestore for later use. For example, a task document might include a work-site coordinate, while a delivery record might store a destination point.

Example Firestore Location Structure

{
  "title": "Site Inspection",
  "latitude": 19.0760,
  "longitude": 72.8777,
  "locationLabel": "Example location",
  "createdAt": "server timestamp"
}

The timestamp in this example is descriptive. Store it using an appropriate Firestore timestamp value rather than the literal text shown above.

For a more structured model, use Firestore's supported geographical point type when suitable. Decide whether to store an address, coordinates, or both based on the application's requirements. Do not store a user's location continuously unless the feature genuinely needs it and the user has been informed.

27. Location Privacy and Security

Location information can reveal sensitive details about a person's routines, home, workplace, and travel. Location handling should therefore be designed around data minimization and user consent.

• Request location permission only when a relevant feature is used.
• Request approximate location when precise location is unnecessary.
• Explain why location access is required.
• Allow the application to function without location when possible.
• Do not collect background location unless the core feature genuinely requires it.
• Restrict access to stored location records through backend security rules.
• Avoid logging precise coordinates unnecessarily.
• Set retention periods and deletion behavior for stored location data.
• Protect API keys with appropriate restrictions.
• Handle denied permissions and revoked permissions without crashing.

28. Battery and Performance Optimization

Location features can affect battery life, network usage, and application responsiveness. The application should request location only as often as necessary.

• Use a one-time location request when continuous tracking is not needed.
• Choose suitable location accuracy and update intervals.
• Stop updates when tracking is no longer required.
• Use lifecycle-aware code to manage location subscriptions.
• Avoid repeatedly geocoding identical coordinates.
• Cache suitable non-sensitive results where allowed.
• Limit the number of markers displayed at one time when handling large datasets.
• Use marker clustering when a map contains many nearby points.
• Handle network failures and loading states gracefully.

29. Common Errors and Troubleshooting

30. Practical Project: Location Finder Application

Project Objective

Create an Android application that displays a Google Map, identifies the user's current location when permission is granted, allows the user to select a point, and displays useful location information.

Required Features

• Display an interactive map.
• Add markers for selected locations.
• Move the camera to a selected marker.
• Request location permission when the user activates the location feature.
• Retrieve and display current coordinates.
• Show an address when reverse geocoding is available.
• Provide an error state for missing permissions or unavailable location data.
• Optionally show nearby places.
• Optionally save selected locations to Firebase.

Development Steps

1. Create an Android Studio project using Kotlin.
2. Configure a Google Cloud project and the Maps SDK for Android.
3. Add the Maps SDK dependency and configure the API key.
4. Build a map screen using SupportMapFragment.
5. Add a marker and configure camera movement.
6. Declare and request the appropriate location permissions.
7. Retrieve a location using Fused Location Provider.
8. Display the coordinates on the map.
9. Add reverse geocoding and error handling.
10. Test on devices with different permission and location settings.

31. Testing Checklist

• Verify that the map loads successfully.
• Test API key restrictions on debug and release builds.
• Confirm that map markers display at the intended coordinates.
• Test zoom, camera movement, and marker selection.
• Verify behavior when location permission is granted.
• Verify behavior when only approximate location is granted.
• Verify behavior when location permission is denied or revoked.
• Test when location services are disabled.
• Handle null, stale, and inaccurate location results.
• Test geocoding when no address is returned.
• Confirm that location updates stop when no longer needed.
• Test network failures and map loading errors.
• Verify that saved location data is protected by backend access rules.

32. Interview Questions and Answers

Q1. What is a location-based service?

A location-based service uses geographical information to provide features such as navigation, nearby search, location sharing, or location-aware notifications.

Q2. What is the Maps SDK for Android?

It is a Google Maps Platform SDK that allows Android applications to display and control interactive Google Maps.

Q3. What is Fused Location Provider?

It is a Google Play services API that combines available device signals to provide location estimates for Android applications.

Q4. What is the difference between coarse and fine location?

Coarse location provides approximate positioning, while fine location allows more precise positioning when available and granted by the user.

Q5. What is the My Location layer?

It is a Maps SDK feature that displays the device's location on the map. It does not provide a programmatic location result for application business logic.

Q6. What is geocoding?

Geocoding converts an address or place description into geographical coordinates.

Q7. What is reverse geocoding?

Reverse geocoding converts coordinates into a readable address when a suitable result is available.

Q8. What is geofencing?

Geofencing monitors entry into or exit from a defined geographical area and can trigger location-related actions.

Q9. Why can the last known location be null?

The device may not have a cached location available. The application may need to request a current location and handle the possibility of failure or timeout.

Q10. How can battery consumption be reduced?

Use location updates only when necessary, choose appropriate accuracy and intervals, and remove location callbacks when the feature no longer needs them.

Q11. Does adding a Google Map automatically calculate directions?

No. The Maps SDK displays the map and its overlays. Route computation typically requires an appropriate directions or routes service.

Q12. How should an application protect location data?

Request minimal permissions, explain the feature, restrict backend access, minimize retention, and avoid unnecessary collection or logging of precise coordinates.

33. Quick Revision Notes

• Use Maps SDK for Android to display interactive maps.
• Use Fused Location Provider to retrieve location data.
• Represent geographical coordinates with latitude and longitude.
• Use markers to identify locations on the map.
• Use CameraUpdateFactory to move or zoom the map camera.
• Declare and request appropriate location permissions.
• Handle approximate location access on newer Android versions.
• Use geocoding and reverse geocoding for address conversion.
• Use a suitable Places or Routes service for advanced features.
• Use geofencing for entry and exit monitoring.
• Reduce unnecessary location updates to save battery.
• Protect location data and API credentials.

34. Conclusion

Integrating maps and location-based features helps Android developers build applications that respond to geographical context. The Maps SDK for Android provides interactive maps, markers, and camera controls, while the Fused Location Provider supplies location information for features that need coordinates.

A reliable implementation should include appropriate permissions, secure API configuration, lifecycle-aware location updates, error handling, and clear privacy practices. Advanced features such as nearby-place search, route calculation, geofencing, and Firebase-based location storage can be added according to the application's requirements.

35. Additional Learning Resources

• Maps SDK for Android Documentation
• Maps and Location Data
• Android Location Permissions
• Retrieve the Current Location
• Geofencing Guide
• Places SDK for Android
• Explore the Android App Development Course at JustAcademy
• Register for a JustAcademy Course Demo
• Visit JustAcademy